home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / 3DGPL.ZIP / 3DGPL / CODE / TRANS / TRANS-FX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-22  |  10.9 KB  |  286 lines
  1. /** 3DGPL *************************************************\
  2.  *  ()                                                    *
  3.  *  3-D transformations of coordinates using fixed point. *
  4.  *                                                        *
  5.  *  Defines:                                              *
  6.  *   T_init_math             Creating sin/cos tables;     *
  7.  *                                                        *
  8.  *   T_translation           Shifting of coordinates;     *
  9.  *   T_scaling               Scaling coordinates;         *
  10.  *                                                        *
  11.  *   T_set_world_rotation    Viewer's rotation;           *
  12.  *   T_world_rotation        Transforming coordinates;    *
  13.  *   T_set_self_rotation     Object rotation;             *
  14.  *   T_self_rotation         Transforming coordinates;    *
  15.  *                                                        *
  16.  *   T_perspective           Transform to perspective.    *
  17.  *                                                        *
  18.  *  Internals:                                            *
  19.  *   TI_float2fixed          Converting float to fixed.   *
  20.  *                                                        *
  21.  *  (6/1995) By Sergei Savchenko. (savs@cs.mcgill.ca).    *
  22.  *  Copyright (c) 1995 Sergei Savchenko.                  *
  23.  *  THIS SOURCE CODE CAN'T BE USED FOR COMERCIAL PURPOSES *
  24.  *  WITHOUT AUTHORISATION                                 *
  25. \**********************************************************/
  26.  
  27. #include <math.h>                           /* sin & cos */
  28. #include "../hardware/hardware.h"           /* 32bit int name */
  29. #include "../trans/trans.h"                 /* 3D mathematics */
  30.  
  31. typedef signed_32_bit fixed;                /* better be 32bit machine */
  32.  
  33. #define T_RADS                  40.7436642  /* pseudo-grads into rads */
  34. #define T_P                             14  /* fixed math precision */
  35.  
  36. fixed T_wx1,T_wx2,T_wx3,T_wy1,T_wy2,T_wy3,T_wz1,T_wz2,T_wz3;
  37. fixed T_sx1,T_sx2,T_sx3,T_sy1,T_sy2,T_sy3,T_sz1,T_sz2,T_sz3;
  38. fixed T_sin[256],T_cos[256];                /* precalculated */
  39.  
  40. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ 
  41.  *  INTERNAL: Converting [-1,1] float into fixed.        *
  42.  *  ---------                                            *
  43. \* * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  44.  
  45. fixed TI_float2fixed(float a)
  46. { 
  47.  fixed res=0;
  48.  int i,dv,sign;
  49.  
  50.  if((sign=a<0.0)==1) a=-a;
  51.  
  52.  for(i=1,dv=2;i<=T_P;i++,dv*=2)
  53.   if(a>=1.0/dv) { a-=1.0/dv; res|=(0x1<<(T_P-i)); };
  54.  
  55.  if(sign==1) res=-res;
  56.  
  57.  return(res);
  58. }
  59.  
  60. /**********************************************************\
  61.  *  Initializing tables.                                  *
  62. \**********************************************************/
  63.  
  64. void T_init_math(void)
  65. {
  66.  int i;
  67.  
  68.  for(i=0;i<256;i++)
  69.  {
  70.   T_sin[i]=TI_float2fixed(sin(i/T_RADS));
  71.   T_cos[i]=TI_float2fixed(cos(i/T_RADS));
  72.  }
  73. } 
  74.  
  75. /**********************************************************\
  76.  *  Translation of coordinates.                           *
  77. \**********************************************************/
  78.  
  79. void T_translation(register int *from,register int *to,int length,
  80.            int addx,int addy,int addz
  81.           )
  82. {
  83.  register int i;
  84.  
  85.  for(i=0;i<length;i++)
  86.  {
  87.   (*to++)=(*from++)+addx;
  88.   (*to++)=(*from++)+addy;
  89.   (*to++)=(*from++)+addz;                   /* translation */
  90.  }
  91. }
  92.  
  93. /**********************************************************\
  94.  *  Scaling coordinates. (takes in float parameters).     *
  95. \**********************************************************/
  96.  
  97. void T_scaling(register int *from,register int *to,int length,
  98.            int mulx,int muly,int mulz
  99.           )
  100. {
  101.  register int i;
  102.  
  103.  for(i=0;i<length;i++)
  104.  {
  105.   (*to++)=(int)(*from++)*mulx;
  106.   (*to++)=(int)(*from++)*muly;
  107.   (*to++)=(int)(*from++)*mulz;
  108.  }                                          /* scaling */
  109. }
  110.  
  111. /**********************************************************\
  112.  *  Constructing rotation matrix. (gam-bet-alp), rotation *
  113.  *  then pitch then roll sequence. gam-rotation, bet-pitch*
  114.  *                                 alp-roll.              *
  115.  *                                                        *
  116.  *          Y^    Z           x'=z*sin(gam)+x*cos(gam)    *
  117.  *           |   /            y'=y                        *
  118.  *           |  / alp         z'=z*cos(gam)-x*sin(gam)    *
  119.  *          /|<---+                                       *
  120.  *         | |/   |           x"=x'                       *
  121.  *  -------|-+-----------> X  y"=y'*cos(bet)-z'*sin(bet)  *
  122.  *     bet | |   __           z"=y'*sin(bet)+z'*cos(bet)  *
  123.  *         V/|   /| gam                                   *
  124.  *         /----+             x"'=y"*sin(alp)+x"*cos(alp) *
  125.  *        /  |                y"'=y"*cos(alp)-x"*sin(alp) *
  126.  *       /   |                z"'=z"                      *
  127.  *           |                                            *
  128. \**********************************************************/
  129.  
  130. void T_set_world_rotation(int alp,int bet,int gam)
  131. {
  132.  fixed cosalp,sinalp,cosbet,sinbet,cosgam,singam;
  133.  
  134.  cosalp=T_cos[alp];
  135.  sinalp=T_sin[alp];
  136.  cosbet=T_cos[bet];
  137.  sinbet=T_sin[bet];
  138.  cosgam=T_cos[gam];
  139.  singam=T_sin[gam];                         /* initializing */
  140.  
  141.  T_wx1=((singam*((sinbet*sinalp)>>T_P))>>T_P) + ((cosgam*cosalp)>>T_P);
  142.  T_wy1=((cosbet*sinalp)>>T_P);
  143.  T_wz1=((singam*cosalp)>>T_P) - ((cosgam*((sinbet*sinalp)>>T_P))>>T_P);
  144.  
  145.  T_wx2=((singam*((sinbet*cosalp)>>T_P))>>T_P) - ((cosgam*sinalp)>>T_P);
  146.  T_wy2=((cosbet*cosalp)>>T_P);
  147.  T_wz2=-((cosgam*((sinbet*cosalp)>>T_P))>>T_P) - ((singam*sinalp)>>T_P);
  148.  
  149.  T_wx3=-((singam*cosbet)>>T_P);
  150.  T_wy3=sinbet;
  151.  T_wz3=((cosgam*cosbet)>>T_P);              /* calculating the matrix */
  152. }
  153.  
  154. /**********************************************************\
  155.  *  Rotating coordinates.                                 *
  156.  *                                        |wx1 wx2 wx3|   *
  157.  *  T'=T[W]  where:  [x' y' z'] = [x y z]*|wy1 wy2 wy3|   *
  158.  *                                        |wz1 wz2 wz3|   *
  159. \**********************************************************/
  160.  
  161. void T_world_rotation(int *from,register int *to,int length)
  162. {
  163.  register int i;
  164.  register int xt,yt,zt;
  165.  
  166.  for(i=0;i<length;i++)
  167.  {
  168.   xt=*from++;
  169.   yt=*from++;
  170.   zt=*from++;
  171.  
  172.   *to++=((T_wx1*xt)>>T_P) + ((T_wy1*yt)>>T_P) + ((T_wz1*zt)>>T_P);
  173.   *to++=((T_wx2*xt)>>T_P) + ((T_wy2*yt)>>T_P) + ((T_wz2*zt)>>T_P);
  174.   *to++=((T_wx3*xt)>>T_P) + ((T_wy3*yt)>>T_P) + ((T_wz3*zt)>>T_P); 
  175.  }
  176. }
  177.  
  178. /**********************************************************\
  179.  *  Constructing rotation matrix. (alp-bet-gam), roll     *
  180.  *  then pitch then rotation sequence. gam-rotation,      *
  181.  *                                     bet-pitch, alp-roll*
  182.  *                                                        *
  183.  *          Y^    Z           x'=y*sin(alp)+x*cos(alp)    *
  184.  *           |   /            y'=y*cos(alp)-x*sin(alp)    *
  185.  *           |  / alp         z'=z                        *
  186.  *          /|<---+                                       *
  187.  *         | |/   |           x"=x'                       *
  188.  *  -------|-+-----------> X  y"=y'*cos(bet)-z'*sin(bet)  *
  189.  *     bet | |   __           z"=y'*sin(bet)+z'*cos(bet)  *
  190.  *         V/|   /| gam                                   *
  191.  *         /----+             x"'=z"*sin(gam)+x"*cos(gam) *
  192.  *        /  |                y"'=y"                      *
  193.  *       /   |                z"'=z"*cos(gam)-x"*sin(gam) *
  194.  *           |                                            *
  195. \**********************************************************/
  196.  
  197. void T_set_self_rotation(int alp,int bet,int gam)
  198. { 
  199.  fixed cosalp,sinalp,cosbet,sinbet,cosgam,singam;
  200.  
  201.  cosalp=T_cos[alp];
  202.  sinalp=T_sin[alp];
  203.  cosbet=T_cos[bet];
  204.  sinbet=T_sin[bet];
  205.  cosgam=T_cos[gam];
  206.  singam=T_sin[gam];                         /* initializing */
  207.  
  208.  T_sx1=((cosalp*cosgam)>>T_P)-((sinalp*((sinbet*singam)>>T_P))>>T_P);
  209.  T_sy1=((sinalp*cosgam)>>T_P)+((cosalp*((sinbet*singam)>>T_P))>>T_P);
  210.  T_sz1=((cosbet*singam)>>T_P);
  211.  
  212.  T_sx2=-((sinalp*cosbet)>>T_P);
  213.  T_sy2=((cosalp*cosbet)>>T_P);
  214.  T_sz2=-sinbet;
  215.  
  216.  T_sx3=-((cosalp*singam)>>T_P)-((sinalp*((sinbet*cosgam)>>T_P))>>T_P);
  217.  T_sy3=((cosalp*((sinbet*cosgam)>>T_P))>>T_P)-((sinalp*singam)>>T_P);
  218.  T_sz3=((cosbet*cosgam)>>T_P);              /* calculating the matrix */
  219. }
  220.  
  221. /**********************************************************\
  222.  *  Rotating coordinates.                                 *
  223.  *                                        |sx1 sx2 sx3|   *
  224.  *  T'=T[S]  where:  [x' y' z'] = [x y z]*|sy1 sy2 sy3|   *
  225.  *                                        |sz1 sz2 sz3|   *
  226. \**********************************************************/
  227.  
  228. void T_self_rotation(int *from,register int *to,int length)
  229. {
  230.  register int i;
  231.  register int xt,yt,zt;
  232.  
  233.  for(i=0;i<length;i++)
  234.  {
  235.   xt=*from++;
  236.   yt=*from++;
  237.   zt=*from++;
  238.  
  239.   *to++=((T_sx1*xt)>>T_P) + ((T_sy1*yt)>>T_P) + ((T_sz1*zt)>>T_P);
  240.   *to++=((T_sx2*xt)>>T_P) + ((T_sy2*yt)>>T_P) + ((T_sz2*zt)>>T_P);
  241.   *to++=((T_sx3*xt)>>T_P) + ((T_sy3*yt)>>T_P) + ((T_sz3*zt)>>T_P); 
  242.  }
  243. }
  244.  
  245. /**********************************************************\
  246.  *  Transforming to perspective, coordinates passed ase   *
  247.  *                        supposed to be both volume, and *
  248.  *                *       Z-clipped, otherwise division   *
  249.  *               /|X      by 0 or overflow can occur.     *
  250.  *              / |                                       *
  251.  *             /  |                                       *
  252.  *            *   |                                       *
  253.  *           /|X' |       X'      X                       *
  254.  *          / |   |    ------- = ---                      *
  255.  *         /  |   |     focus     Z                       *
  256.  *        *---+---+                                       *
  257.  *        0   ^   Z    X'= X*focus/Z                      *
  258.  *            |                                           *
  259.  *          focus                                         *
  260.  *                                                        *
  261.  *  ADDITIONAL FUNCTIONS: 1) changing formats:            *
  262.  *  ---------------------                                 *
  263.  *    source:       x, y ,z,a1,...,aN where N==dimension-3*
  264.  *    destanation:  x',y',  a1,...,aN                     *   
  265.  *                                                        *
  266.  *  2) performs translation to the screen centre.         *
  267. \**********************************************************/
  268.  
  269. void T_perspective(register int *from,register int *to,
  270.            int dimension,int length
  271.           )
  272. {
  273.  register int i;
  274.  
  275.  dimension-=3;                              /* other then X,Y */
  276.  
  277.  for(i=0;i<length;i++,from+=dimension,to+=dimension) 
  278.  {                                          /* Z is not being changed */
  279.   to[0]=((((long)from[0])<<T_LOG_FOCUS)/from[2])+HW_SCREEN_X_CENTRE;
  280.   to[1]=((((long)from[1])<<T_LOG_FOCUS)/from[2])+HW_SCREEN_Y_CENTRE;
  281.   HW_copy_int(from+=3,to+=2,dimension);
  282.  }
  283. }
  284.  
  285. /**********************************************************/
  286.